M

MLOG

Latviešu

Padziļināts ceļvedis par JavaScript Temporal API – mūsdienīgu risinājumu efektīvai datumu un laiku apstrādei dažādos starptautiskos kontekstos.

JavaScript Temporal API: Mūsdienīga datuma un laika apstrāde globālai auditorijai

JavaScript `Date` objekts ilgu laiku ir sagādājis vilšanos izstrādātājiem. Tā mainīgums, nekonsekventais API un vājais laika joslu atbalsts ir novedis pie daudzu bibliotēku, piemēram, Moment.js un date-fns, izveides, lai aizpildītu šos trūkumus. Tagad, ar Temporal API, JavaScript piedāvā modernu, iebūvētu risinājumu datumu un laiku apstrādei ar uzlabotu skaidrību un precizitāti. Šis raksts sniedz visaptverošu pārskatu par Temporal API, koncentrējoties uz tā funkcijām, priekšrocībām un lietojumu dažādos starptautiskos kontekstos.

Kas ir Temporal API?

Temporal API ir jauns, globāls objekts JavaScript valodā, kas izstrādāts, lai novērstu `Date` objekta trūkumus. Tas nodrošina tīru, nemainīgu (immutable) API darbam ar datumiem, laikiem, laika joslām un kalendāru sistēmām. Būtiski, ka tā mērķis ir attēlot datuma un laika jēdzienus veidā, kas ciešāk atbilst reālās pasaules lietojumam un gaidām, padarot internacionalizāciju daudz vienkāršāku.

Galvenās iezīmes:

Pamata Temporal objekti

Temporal API ievieš vairākus jaunus objektu tipus. Šeit ir daži no galvenajiem:

Darbs ar datumiem

`Temporal.PlainDate` izveide

Lai izveidotu `Temporal.PlainDate`, varat izmantot konstruktoru:

const plainDate = new Temporal.PlainDate(2024, 10, 27); // Gads, mēnesis (1-12), diena
console.log(plainDate.toString()); // Izvade: 2024-10-27

Varat arī izmantot metodi `from`, kas pieņem virkni ISO 8601 formātā:

const plainDateFromString = Temporal.PlainDate.from('2024-10-27');
console.log(plainDateFromString.toString()); // Izvade: 2024-10-27

Datuma komponentu iegūšana

Jūs varat piekļūt atsevišķiem datuma komponentiem, izmantojot īpašības kā `year`, `month` un `day`:

console.log(plainDate.year); // Izvade: 2024
console.log(plainDate.month); // Izvade: 10
console.log(plainDate.day); // Izvade: 27

Datumu aritmētika

Lai pievienotu vai atņemtu dienas, nedēļas, mēnešus vai gadus, izmantojiet metodes `plus` un `minus`. Šīs metodes atgriež jaunu `Temporal.PlainDate` objektu:

const nextWeek = plainDate.plus({ days: 7 });
console.log(nextWeek.toString()); // Izvade: 2024-11-03

const lastMonth = plainDate.minus({ months: 1 });
console.log(lastMonth.toString()); // Izvade: 2024-09-27

Datumu salīdzināšana

Jūs varat salīdzināt datumus, izmantojot metodi `compare`:

const date1 = new Temporal.PlainDate(2024, 10, 27);
const date2 = new Temporal.PlainDate(2024, 11, 15);

console.log(Temporal.PlainDate.compare(date1, date2)); // Izvade: -1 (date1 ir agrāks par date2)

Darbs ar laikiem

`Temporal.PlainTime` izveide

Lai izveidotu `Temporal.PlainTime`, izmantojiet konstruktoru:

const plainTime = new Temporal.PlainTime(10, 30, 0); // Stunda, minūte, sekunde
console.log(plainTime.toString()); // Izvade: 10:30:00

Vai izmantojiet metodi `from` ar ISO 8601 laika virkni:

const plainTimeFromString = Temporal.PlainTime.from('10:30:00');
console.log(plainTimeFromString.toString()); // Izvade: 10:30:00

Laika komponentu iegūšana

console.log(plainTime.hour); // Izvade: 10
console.log(plainTime.minute); // Izvade: 30
console.log(plainTime.second); // Izvade: 0

Laika aritmētika

const later = plainTime.plus({ minutes: 15 });
console.log(later.toString()); // Izvade: 10:45:00

Darbs ar datumu un laiku kopā

`Temporal.PlainDateTime` izveide

Jūs varat izveidot `Temporal.PlainDateTime` tieši vai apvienojot `Temporal.PlainDate` un `Temporal.PlainTime`:

const plainDateTime = new Temporal.PlainDateTime(2024, 10, 27, 10, 30, 0);
console.log(plainDateTime.toString()); // Izvade: 2024-10-27T10:30:00

const date = new Temporal.PlainDate(2024, 10, 27);
const time = new Temporal.PlainTime(10, 30, 0);
const combinedDateTime = date.toPlainDateTime(time);
console.log(combinedDateTime.toString()); // Izvade: 2024-10-27T10:30:00

Laika joslas

Pareiza laika joslu apstrāde ir būtiska lietojumprogrammām, kas strādā ar lietotājiem dažādās atrašanās vietās. Temporal API nodrošina spēcīgu laika joslu atbalstu, izmantojot `Temporal.ZonedDateTime` un `Temporal.TimeZone` objektus.

`Temporal.ZonedDateTime` izveide

Lai izveidotu `Temporal.ZonedDateTime`, jums ir nepieciešams `Temporal.PlainDateTime` un laika joslas identifikators. Laika joslu identifikatori ir balstīti uz IANA laika joslu datubāzi (piem., `America/Los_Angeles`, `Europe/London`, `Asia/Tokyo`).

const plainDateTime = new Temporal.PlainDateTime(2024, 10, 27, 10, 30, 0);
const timeZone = 'America/Los_Angeles';
const zonedDateTime = plainDateTime.toZonedDateTime(timeZone);
console.log(zonedDateTime.toString()); // Izvade: 2024-10-27T10:30:00-07:00[America/Los_Angeles] (Nobīde būs atkarīga no vasaras laika noteikumiem)

Alternatīvi, izveidojiet `Temporal.ZonedDateTime` no `Instant`.

const instant = Temporal.Instant.fromEpochSeconds(1666866600); // Laikspiedoga piemērs
const zonedDateTimeFromInstant = instant.toZonedDateTimeISO(timeZone); // Laika josla, piemēram, 'America/Los_Angeles'
console.log(zonedDateTimeFromInstant.toString());

Konvertēšana starp laika joslām

Jūs varat konvertēt `Temporal.ZonedDateTime` uz citu laika joslu, izmantojot metodi `withTimeZone`:

const newTimeZone = 'Europe/London';
const zonedDateTimeInLondon = zonedDateTime.withTimeZone(newTimeZone);
console.log(zonedDateTimeInLondon.toString()); // Izvade: 2024-10-27T18:30:00+01:00[Europe/London]

Darbs ar laika joslu nobīdēm

`Temporal.TimeZone` objekta metode `getOffsetStringFor` nodrošina nobīdes virkni konkrētam `Temporal.Instant`:

const timeZoneObject = new Temporal.TimeZone(timeZone);
const offsetString = timeZoneObject.getOffsetStringFor(zonedDateTime.toInstant());
console.log(offsetString); // Izvade: -07:00 (Atkarībā no vasaras laika noteikumiem)

Precīziem aprēķiniem ir būtiski izmantot pareizos IANA laika joslu identifikatorus. Šie identifikatori tiek regulāri uzturēti un atjaunināti, lai atspoguļotu izmaiņas vasaras laikā un laika joslu robežās.

Ilgumi

`Temporal.Duration` objekts pārstāv laika posmu. To var izmantot, lai pievienotu vai atņemtu no datumiem un laikiem.

`Temporal.Duration` izveide

Jūs varat izveidot `Temporal.Duration`, izmantojot konstruktoru, norādot gadus, mēnešus, dienas, stundas, minūtes, sekundes, milisekundes, mikrosekundes un nanosekundes:

const duration = new Temporal.Duration(1, 2, 3, 4, 5, 6, 7, 8, 9); // Gadi, mēneši, dienas, stundas, minūtes, sekundes, milisekundes, mikrosekundes un nanosekundes
console.log(duration.toString()); // Izvade: P1Y2M3DT4H5M6.007008009S

Vai izmantojot ISO 8601 ilguma virkni:

const durationFromString = Temporal.Duration.from('P1Y2M3DT4H5M6S');
console.log(durationFromString.toString()); // Izvade: P1Y2M3DT4H5M6S

Ilgumu pievienošana datumiem un laikiem

const plainDate = new Temporal.PlainDate(2024, 10, 27);
const duration = new Temporal.Duration(0, 0, 7); // 7 dienas
const newDate = plainDate.plus(duration);
console.log(newDate.toString()); // Izvade: 2024-11-03

Ņemiet vērā, ka, pievienojot datumiem ilgumus, kas ietver mēnešus vai gadus, ir nepieciešama rūpīga apsvēršana, jo dienu skaits mēnesī vai gadā var atšķirties.

Kalendāru sistēmas

Temporal API atbalsta dažādas kalendāru sistēmas papildus Gregora kalendāram. Tas ir būtiski lietojumprogrammām, kurām nepieciešams apstrādāt datumus dažādos kultūras kontekstos. Lai gan atbalsts joprojām attīstās, tas nodrošina pamatu turpmākai paplašināšanai.

Alternatīvu kalendāru izmantošana

Lai izmantotu konkrētu kalendāru, to var norādīt, veidojot Temporal objektus:

const hebrewDate = new Temporal.PlainDate(5785, 1, 1, { calendar: 'hebrew' });
console.log(hebrewDate.toString()); // Konkrētā izvade var atšķirties atkarībā no implementācijas un formatēšanas. Rakstīšanas brīdī daudzās vidēs nepieciešams polyfill.

Svarīgi: Atbalstam kalendāriem, kas nav Gregora kalendārs, var būt nepieciešami polyfills vai specifisks pārlūkprogrammas/vides atbalsts. Pārbaudiet jaunākās Temporal API dokumentācijas un pārlūkprogrammu saderības tabulas, lai iegūtu jaunāko informāciju.

Datumu un laiku formatēšana

Kamēr Temporal API koncentrējas uz datuma un laika manipulācijām, formatēšanu parasti veic ar `Intl.DateTimeFormat` objektu, kas ir daļa no Internacionalizācijas API. Temporal objekti nevainojami darbojas ar `Intl.DateTimeFormat`.

`Intl.DateTimeFormat` izmantošana

Šeit ir parādīts, kā formatēt `Temporal.PlainDate`, izmantojot `Intl.DateTimeFormat`:

const plainDate = new Temporal.PlainDate(2024, 10, 27);
const formatter = new Intl.DateTimeFormat('en-US', { year: 'numeric', month: 'long', day: 'numeric' });
console.log(formatter.format(plainDate)); // Izvade: October 27, 2024

const formatterGerman = new Intl.DateTimeFormat('de-DE', { year: 'numeric', month: 'long', day: 'numeric' });
console.log(formatterGerman.format(plainDate)); // Izvade: 27. Oktober 2024

Jūs varat pielāgot formāta opcijas atbilstoši savām vajadzībām. Pirmais arguments `Intl.DateTimeFormat` ir lokalizācija (locale), kas nosaka valodu un reģionālās konvencijas, ko izmanto formatēšanai. Izmantojot dažādas lokalizācijas (piem., 'en-US', 'de-DE', 'fr-FR', 'ja-JP'), tiek iegūti dažādi izvades formāti.

`Temporal.ZonedDateTime` formatēšana

`Temporal.ZonedDateTime` formatēšana ir līdzīga, bet izvadē varat iekļaut arī laika joslas informāciju:

const plainDateTime = new Temporal.PlainDateTime(2024, 10, 27, 10, 30, 0);
const timeZone = 'America/Los_Angeles';
const zonedDateTime = plainDateTime.toZonedDateTime(timeZone);

const formatter = new Intl.DateTimeFormat('en-US', { year: 'numeric', month: 'long', day: 'numeric', hour: 'numeric', minute: 'numeric', timeZoneName: 'short' });
console.log(formatter.format(zonedDateTime)); // Izvade: October 27, 2024, 10:30 AM PDT (Laika joslas saīsinājums atkarīgs no vasaras laika noteikumiem)

Internacionalizācijas labākās prakses

Strādājot ar datumiem un laikiem globālā kontekstā, ņemiet vērā šādas labākās prakses:

Temporal API salīdzinājums ar veco Date objektu

Šeit ir tabula, kas izceļ galvenās atšķirības un Temporal API priekšrocības salīdzinājumā ar veco `Date` objektu:

Iezīme Vecais `Date` objekts Temporal API
Mainīgums Mainīgs (modificē sākotnējo objektu) Nemainīgs (atgriež jaunus objektus)
Laika joslu atbalsts Ierobežots un bieži problemātisks Spēcīgs un precīzs, balstīts uz IANA laika joslu datubāzi
API Nekonsekvents un grūti lietojams Skaidrs, konsekvents un intuitīvs
Precizitāte Milisekunde Nanosekunde
Kalendāru sistēmas Tikai Gregora kalendārs Atbalsta alternatīvas kalendāru sistēmas (ar attīstošu atbalstu)
Internacionalizācija Nepieciešamas ārējas bibliotēkas spēcīgai internacionalizācijai Iebūvēts atbalsts un nevainojama integrācija ar `Intl.DateTimeFormat`

Pārlūkprogrammu atbalsts un polyfills

Tā kā Temporal API ir salīdzinoši jauns, pārlūkprogrammu atbalsts tam joprojām attīstās. Pārbaudiet jaunākās pārlūkprogrammu saderības tabulas (piemēram, MDN Web Docs), lai redzētu, kuras pārlūkprogrammas un vides to atbalsta dabiski. Vecākām pārlūkprogrammām vai vidēm bez dabiska atbalsta varat izmantot polyfills, lai nodrošinātu Temporal API funkcionalitāti. Meklējiet tīmeklī "Temporal API polyfill", lai atrastu piemērotas iespējas.

Noslēgums

JavaScript Temporal API ir nozīmīgs solis uz priekšu datumu un laiku apstrādē JavaScript valodā. Tā nemainīgums, skaidrais API, spēcīgais laika joslu atbalsts un kalendāru sistēmu iespējas padara to par jaudīgu rīku izstrādātājiem, kas veido lietojumprogrammas, kurām nepieciešams precīzi un uzticami strādāt ar datumiem un laikiem dažādos starptautiskos kontekstos. Lai gan pārlūkprogrammu atbalsts joprojām attīstās, Temporal API priekšrocības padara to par vērtīgu apgūšanai un ieviešanai jaunos projektos. Pieņemot Temporal API un ievērojot internacionalizācijas labākās prakses, jūs varat izveidot lietojumprogrammas, kas nodrošina nevainojamu un precīzu datuma un laika pieredzi lietotājiem visā pasaulē.

Papildu materiāli

JavaScript Temporal API: Mūsdienīga datuma un laika apstrāde globālai auditorijai | MLOG